"""
workers service

Provides an API for worker machines, allowing workers to report status and get tasks for execution
"""
from typing import List, Optional, Any
import six
from datetime import datetime
import enum
from dateutil.parser import parse as parse_datetime
from clearml.backend_api.session import (
    Request,
    Response,
    NonStrictDataModel,
    schema_property,
    StringEnum,
)


class MetricsCategory(NonStrictDataModel):
    """
    :param name: Name of the metrics category.
    :type name: str
    :param metric_keys: The names of the metrics in the category.
    :type metric_keys: Sequence[str]
    """

    _schema = {
        "properties": {
            "metric_keys": {
                "description": "The names of the metrics in the category.",
                "items": {"type": "string"},
                "type": ["array", "null"],
            },
            "name": {
                "description": "Name of the metrics category.",
                "type": ["string", "null"],
            },
        },
        "type": "object",
    }

    def __init__(self, name: Optional[str] = None, metric_keys: Optional[List[str]] = None, **kwargs: Any) -> None:
        super(MetricsCategory, self).__init__(**kwargs)
        self.name = name
        self.metric_keys = metric_keys

    @schema_property("name")
    def name(self) -> Optional[str]:
        return self._property_name

    @name.setter
    def name(self, value: Optional[str]) -> None:
        if value is None:
            self._property_name = None
            return
        self.assert_isinstance(value, "name", six.string_types)
        self._property_name = value

    @schema_property("metric_keys")
    def metric_keys(self) -> Optional[List[str]]:
        return self._property_metric_keys

    @metric_keys.setter
    def metric_keys(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_metric_keys = None
            return
        self.assert_isinstance(value, "metric_keys", (list, tuple))
        self.assert_isinstance(value, "metric_keys", six.string_types, is_array=True)
        self._property_metric_keys = value


class AggregationType(StringEnum):
    avg = "avg"
    min = "min"
    max = "max"


class StatItem(NonStrictDataModel):
    """
    :param key: Name of a metric
    :type key: str
    :param category:
    :type category: AggregationType
    """

    _schema = {
        "properties": {
            "category": {"oneOf": [{"$ref": "#/definitions/aggregation_type"}, {"type": "null"}]},
            "key": {"description": "Name of a metric", "type": ["string", "null"]},
        },
        "type": "object",
    }

    def __init__(self, key: Optional[str] = None, category: Any = None, **kwargs: Any) -> None:
        super(StatItem, self).__init__(**kwargs)
        self.key = key
        self.category = category

    @schema_property("key")
    def key(self) -> Optional[str]:
        return self._property_key

    @key.setter
    def key(self, value: Optional[str]) -> None:
        if value is None:
            self._property_key = None
            return
        self.assert_isinstance(value, "key", six.string_types)
        self._property_key = value

    @schema_property("category")
    def category(self) -> Any:
        return self._property_category

    @category.setter
    def category(self, value: Any) -> None:
        if value is None:
            self._property_category = None
            return
        if isinstance(value, six.string_types):
            try:
                value = AggregationType(value)
            except ValueError:
                pass
        else:
            self.assert_isinstance(value, "category", enum.Enum)
        self._property_category = value


class AggregationStats(NonStrictDataModel):
    """
    :param aggregation:
    :type aggregation: AggregationType
    :param values: List of values corresponding to the dates in metric statistics
    :type values: Sequence[float]
    """

    _schema = {
        "properties": {
            "aggregation": {"oneOf": [{"$ref": "#/definitions/aggregation_type"}, {"type": "null"}]},
            "values": {
                "description": "List of values corresponding to the dates in metric statistics",
                "items": {"type": "number"},
                "type": ["array", "null"],
            },
        },
        "type": "object",
    }

    def __init__(self, aggregation: Any = None, values: Optional[List[float]] = None, **kwargs: Any) -> None:
        super(AggregationStats, self).__init__(**kwargs)
        self.aggregation = aggregation
        self.values = values

    @schema_property("aggregation")
    def aggregation(self) -> Any:
        return self._property_aggregation

    @aggregation.setter
    def aggregation(self, value: Any) -> None:
        if value is None:
            self._property_aggregation = None
            return
        if isinstance(value, six.string_types):
            try:
                value = AggregationType(value)
            except ValueError:
                pass
        else:
            self.assert_isinstance(value, "aggregation", enum.Enum)
        self._property_aggregation = value

    @schema_property("values")
    def values(self) -> Optional[List[float]]:
        return self._property_values

    @values.setter
    def values(self, value: Optional[List[float]]) -> None:
        if value is None:
            self._property_values = None
            return
        self.assert_isinstance(value, "values", (list, tuple))
        self.assert_isinstance(value, "values", six.integer_types + (float,), is_array=True)
        self._property_values = value


class MetricStats(NonStrictDataModel):
    """
    :param metric: Name of the metric (cpu_usage, memory_used etc.)
    :type metric: str
    :param variant: Name of the metric component. Set only if 'split_by_variant'
        was set in the request
    :type variant: str
    :param dates: List of timestamps (in seconds from epoch) in the acceding order.
        The timestamps are separated by the requested interval. Timestamps where no
        workers activity was recorded are omitted.
    :type dates: Sequence[int]
    :param stats: Statistics data by type
    :type stats: Sequence[AggregationStats]
    """

    _schema = {
        "properties": {
            "dates": {
                "description": "List of timestamps (in seconds from epoch) in the acceding order. The timestamps are separated by the requested interval. Timestamps where no workers activity was recorded are omitted.",
                "items": {"type": "integer"},
                "type": ["array", "null"],
            },
            "metric": {
                "description": "Name of the metric (cpu_usage, memory_used etc.)",
                "type": ["string", "null"],
            },
            "stats": {
                "description": "Statistics data by type",
                "items": {"$ref": "#/definitions/aggregation_stats"},
                "type": ["array", "null"],
            },
            "variant": {
                "description": "Name of the metric component. Set only if 'split_by_variant' was set in the request",
                "type": ["string", "null"],
            },
        },
        "type": "object",
    }

    def __init__(
        self,
        metric: Optional[str] = None,
        variant: Optional[str] = None,
        dates: Optional[List[int]] = None,
        stats: Optional[List[Any]] = None,
        **kwargs: Any
    ) -> None:
        super(MetricStats, self).__init__(**kwargs)
        self.metric = metric
        self.variant = variant
        self.dates = dates
        self.stats = stats

    @schema_property("metric")
    def metric(self) -> Optional[str]:
        return self._property_metric

    @metric.setter
    def metric(self, value: Optional[str]) -> None:
        if value is None:
            self._property_metric = None
            return
        self.assert_isinstance(value, "metric", six.string_types)
        self._property_metric = value

    @schema_property("variant")
    def variant(self) -> Optional[str]:
        return self._property_variant

    @variant.setter
    def variant(self, value: Optional[str]) -> None:
        if value is None:
            self._property_variant = None
            return
        self.assert_isinstance(value, "variant", six.string_types)
        self._property_variant = value

    @schema_property("dates")
    def dates(self) -> Optional[List[int]]:
        return self._property_dates

    @dates.setter
    def dates(self, value: Optional[List[int]]) -> None:
        if value is None:
            self._property_dates = None
            return
        self.assert_isinstance(value, "dates", (list, tuple))
        value = [int(v) if isinstance(v, float) and v.is_integer() else v for v in value]
        self.assert_isinstance(value, "dates", six.integer_types, is_array=True)
        self._property_dates = value

    @schema_property("stats")
    def stats(self) -> Optional[List[Any]]:
        return self._property_stats

    @stats.setter
    def stats(self, value: Optional[List[Any]]) -> None:
        if value is None:
            self._property_stats = None
            return
        self.assert_isinstance(value, "stats", (list, tuple))
        if any((isinstance(v, dict) for v in value)):
            value = [AggregationStats.from_dict(v) if isinstance(v, dict) else v for v in value]
        else:
            self.assert_isinstance(value, "stats", AggregationStats, is_array=True)
        self._property_stats = value


class WorkerStats(NonStrictDataModel):
    """
    :param worker: ID of the worker
    :type worker: str
    :param metrics: List of the metrics statistics for the worker
    :type metrics: Sequence[MetricStats]
    """

    _schema = {
        "properties": {
            "metrics": {
                "description": "List of the metrics statistics for the worker",
                "items": {"$ref": "#/definitions/metric_stats"},
                "type": ["array", "null"],
            },
            "worker": {"description": "ID of the worker", "type": ["string", "null"]},
        },
        "type": "object",
    }

    def __init__(self, worker: Optional[str] = None, metrics: Optional[List[Any]] = None, **kwargs: Any) -> None:
        super(WorkerStats, self).__init__(**kwargs)
        self.worker = worker
        self.metrics = metrics

    @schema_property("worker")
    def worker(self) -> Optional[str]:
        return self._property_worker

    @worker.setter
    def worker(self, value: Optional[str]) -> None:
        if value is None:
            self._property_worker = None
            return
        self.assert_isinstance(value, "worker", six.string_types)
        self._property_worker = value

    @schema_property("metrics")
    def metrics(self) -> Optional[List[Any]]:
        return self._property_metrics

    @metrics.setter
    def metrics(self, value: Optional[List[Any]]) -> None:
        if value is None:
            self._property_metrics = None
            return
        self.assert_isinstance(value, "metrics", (list, tuple))
        if any((isinstance(v, dict) for v in value)):
            value = [MetricStats.from_dict(v) if isinstance(v, dict) else v for v in value]
        else:
            self.assert_isinstance(value, "metrics", MetricStats, is_array=True)
        self._property_metrics = value


class ActivitySeries(NonStrictDataModel):
    """
    :param dates: List of timestamps (in seconds from epoch) in the acceding order.
        The timestamps are separated by the requested interval.
    :type dates: Sequence[int]
    :param counts: List of worker counts corresponding to the timestamps in the
        dates list. None values are returned for the dates with no workers.
    :type counts: Sequence[int]
    """

    _schema = {
        "properties": {
            "counts": {
                "description": "List of worker counts corresponding to the timestamps in the dates list. None values are returned for the dates with no workers.",
                "items": {"type": "integer"},
                "type": ["array", "null"],
            },
            "dates": {
                "description": "List of timestamps (in seconds from epoch) in the acceding order. The timestamps are separated by the requested interval.",
                "items": {"type": "integer"},
                "type": ["array", "null"],
            },
        },
        "type": "object",
    }

    def __init__(self, dates: Optional[List[int]] = None, counts: Optional[List[int]] = None, **kwargs: Any) -> None:
        super(ActivitySeries, self).__init__(**kwargs)
        self.dates = dates
        self.counts = counts

    @schema_property("dates")
    def dates(self) -> Optional[List[int]]:
        return self._property_dates

    @dates.setter
    def dates(self, value: Optional[List[int]]) -> None:
        if value is None:
            self._property_dates = None
            return
        self.assert_isinstance(value, "dates", (list, tuple))
        value = [int(v) if isinstance(v, float) and v.is_integer() else v for v in value]
        self.assert_isinstance(value, "dates", six.integer_types, is_array=True)
        self._property_dates = value

    @schema_property("counts")
    def counts(self) -> Optional[List[int]]:
        return self._property_counts

    @counts.setter
    def counts(self, value: Optional[List[int]]) -> None:
        if value is None:
            self._property_counts = None
            return
        self.assert_isinstance(value, "counts", (list, tuple))
        value = [int(v) if isinstance(v, float) and v.is_integer() else v for v in value]
        self.assert_isinstance(value, "counts", six.integer_types, is_array=True)
        self._property_counts = value


class Worker(NonStrictDataModel):
    """
    :param id: Worker ID
    :type id: str
    :param user: Associated user (under whose credentials are used by the worker
        daemon)
    :type user: IdNameEntry
    :param company: Associated company
    :type company: IdNameEntry
    :param ip: IP of the worker
    :type ip: str
    :param register_time: Registration time
    :type register_time: datetime.datetime
    :param last_activity_time: Last activity time (even if an error occurred)
    :type last_activity_time: datetime.datetime
    :param last_report_time: Last successful report time
    :type last_report_time: datetime.datetime
    :param task: Task currently being run by the worker
    :type task: CurrentTaskEntry
    :param project: Project in which currently executing task resides
    :type project: IdNameEntry
    :param queue: Queue from which running task was taken
    :type queue: QueueEntry
    :param queues: List of queues on which the worker is listening
    :type queues: Sequence[QueueEntry]
    :param tags: User tags for the worker
    :type tags: Sequence[str]
    :param system_tags: System tags for the worker
    :type system_tags: Sequence[str]
    :param key: Worker entry key
    :type key: str
    """

    _schema = {
        "properties": {
            "company": {
                "description": "Associated company",
                "oneOf": [{"$ref": "#/definitions/id_name_entry"}, {"type": "null"}],
            },
            "id": {"description": "Worker ID", "type": ["string", "null"]},
            "ip": {"description": "IP of the worker", "type": ["string", "null"]},
            "key": {"description": "Worker entry key", "type": ["string", "null"]},
            "last_activity_time": {
                "description": "Last activity time (even if an error occurred)",
                "format": "date-time",
                "type": ["string", "null"],
            },
            "last_report_time": {
                "description": "Last successful report time",
                "format": "date-time",
                "type": ["string", "null"],
            },
            "project": {
                "description": "Project in which currently executing task resides",
                "oneOf": [{"$ref": "#/definitions/id_name_entry"}, {"type": "null"}],
            },
            "queue": {
                "description": "Queue from which running task was taken",
                "oneOf": [{"$ref": "#/definitions/queue_entry"}, {"type": "null"}],
            },
            "queues": {
                "description": "List of queues on which the worker is listening",
                "items": {"$ref": "#/definitions/queue_entry"},
                "type": ["array", "null"],
            },
            "register_time": {
                "description": "Registration time",
                "format": "date-time",
                "type": ["string", "null"],
            },
            "system_tags": {
                "description": "System tags for the worker",
                "items": {"type": "string"},
                "type": ["array", "null"],
            },
            "tags": {
                "description": "User tags for the worker",
                "items": {"type": "string"},
                "type": ["array", "null"],
            },
            "task": {
                "description": "Task currently being run by the worker",
                "oneOf": [
                    {"$ref": "#/definitions/current_task_entry"},
                    {"type": "null"},
                ],
            },
            "user": {
                "description": "Associated user (under whose credentials are used by the worker daemon)",
                "oneOf": [{"$ref": "#/definitions/id_name_entry"}, {"type": "null"}],
            },
        },
        "type": "object",
    }

    def __init__(
        self,
        id: Optional[str] = None,
        user: Any = None,
        company: Any = None,
        ip: Optional[str] = None,
        register_time: Optional[str] = None,
        last_activity_time: Optional[str] = None,
        last_report_time: Optional[str] = None,
        task: Any = None,
        project: Any = None,
        queue: Any = None,
        queues: Optional[List[Any]] = None,
        tags: Optional[List[str]] = None,
        system_tags: Optional[List[str]] = None,
        key: Optional[str] = None,
        **kwargs: Any
    ) -> None:
        super(Worker, self).__init__(**kwargs)
        self.id = id
        self.user = user
        self.company = company
        self.ip = ip
        self.register_time = register_time
        self.last_activity_time = last_activity_time
        self.last_report_time = last_report_time
        self.task = task
        self.project = project
        self.queue = queue
        self.queues = queues
        self.tags = tags
        self.system_tags = system_tags
        self.key = key

    @schema_property("id")
    def id(self) -> Optional[str]:
        return self._property_id

    @id.setter
    def id(self, value: Optional[str]) -> None:
        if value is None:
            self._property_id = None
            return
        self.assert_isinstance(value, "id", six.string_types)
        self._property_id = value

    @schema_property("user")
    def user(self) -> Any:
        return self._property_user

    @user.setter
    def user(self, value: Any) -> None:
        if value is None:
            self._property_user = None
            return
        if isinstance(value, dict):
            value = IdNameEntry.from_dict(value)
        else:
            self.assert_isinstance(value, "user", IdNameEntry)
        self._property_user = value

    @schema_property("company")
    def company(self) -> Any:
        return self._property_company

    @company.setter
    def company(self, value: Any) -> None:
        if value is None:
            self._property_company = None
            return
        if isinstance(value, dict):
            value = IdNameEntry.from_dict(value)
        else:
            self.assert_isinstance(value, "company", IdNameEntry)
        self._property_company = value

    @schema_property("ip")
    def ip(self) -> Optional[str]:
        return self._property_ip

    @ip.setter
    def ip(self, value: Optional[str]) -> None:
        if value is None:
            self._property_ip = None
            return
        self.assert_isinstance(value, "ip", six.string_types)
        self._property_ip = value

    @schema_property("register_time")
    def register_time(self) -> Optional[str]:
        return self._property_register_time

    @register_time.setter
    def register_time(self, value: Optional[str]) -> None:
        if value is None:
            self._property_register_time = None
            return
        self.assert_isinstance(value, "register_time", six.string_types + (datetime,))
        if not isinstance(value, datetime):
            value = parse_datetime(value)
        self._property_register_time = value

    @schema_property("last_activity_time")
    def last_activity_time(self) -> Optional[str]:
        return self._property_last_activity_time

    @last_activity_time.setter
    def last_activity_time(self, value: Optional[str]) -> None:
        if value is None:
            self._property_last_activity_time = None
            return
        self.assert_isinstance(value, "last_activity_time", six.string_types + (datetime,))
        if not isinstance(value, datetime):
            value = parse_datetime(value)
        self._property_last_activity_time = value

    @schema_property("last_report_time")
    def last_report_time(self) -> Optional[str]:
        return self._property_last_report_time

    @last_report_time.setter
    def last_report_time(self, value: Optional[str]) -> None:
        if value is None:
            self._property_last_report_time = None
            return
        self.assert_isinstance(value, "last_report_time", six.string_types + (datetime,))
        if not isinstance(value, datetime):
            value = parse_datetime(value)
        self._property_last_report_time = value

    @schema_property("task")
    def task(self) -> Any:
        return self._property_task

    @task.setter
    def task(self, value: Any) -> None:
        if value is None:
            self._property_task = None
            return
        if isinstance(value, dict):
            value = CurrentTaskEntry.from_dict(value)
        else:
            self.assert_isinstance(value, "task", CurrentTaskEntry)
        self._property_task = value

    @schema_property("project")
    def project(self) -> Any:
        return self._property_project

    @project.setter
    def project(self, value: Any) -> None:
        if value is None:
            self._property_project = None
            return
        if isinstance(value, dict):
            value = IdNameEntry.from_dict(value)
        else:
            self.assert_isinstance(value, "project", IdNameEntry)
        self._property_project = value

    @schema_property("queue")
    def queue(self) -> Any:
        return self._property_queue

    @queue.setter
    def queue(self, value: Any) -> None:
        if value is None:
            self._property_queue = None
            return
        if isinstance(value, dict):
            value = QueueEntry.from_dict(value)
        else:
            self.assert_isinstance(value, "queue", QueueEntry)
        self._property_queue = value

    @schema_property("queues")
    def queues(self) -> Optional[List[Any]]:
        return self._property_queues

    @queues.setter
    def queues(self, value: Optional[List[Any]]) -> None:
        if value is None:
            self._property_queues = None
            return
        self.assert_isinstance(value, "queues", (list, tuple))
        if any((isinstance(v, dict) for v in value)):
            value = [QueueEntry.from_dict(v) if isinstance(v, dict) else v for v in value]
        else:
            self.assert_isinstance(value, "queues", QueueEntry, is_array=True)
        self._property_queues = value

    @schema_property("tags")
    def tags(self) -> Optional[List[str]]:
        return self._property_tags

    @tags.setter
    def tags(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_tags = None
            return
        self.assert_isinstance(value, "tags", (list, tuple))
        self.assert_isinstance(value, "tags", six.string_types, is_array=True)
        self._property_tags = value

    @schema_property("system_tags")
    def system_tags(self) -> Optional[List[str]]:
        return self._property_system_tags

    @system_tags.setter
    def system_tags(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_system_tags = None
            return
        self.assert_isinstance(value, "system_tags", (list, tuple))
        self.assert_isinstance(value, "system_tags", six.string_types, is_array=True)
        self._property_system_tags = value

    @schema_property("key")
    def key(self) -> Optional[str]:
        return self._property_key

    @key.setter
    def key(self, value: Optional[str]) -> None:
        if value is None:
            self._property_key = None
            return
        self.assert_isinstance(value, "key", six.string_types)
        self._property_key = value


class IdNameEntry(NonStrictDataModel):
    """
    :param id: Worker ID
    :type id: str
    :param name: Worker name
    :type name: str
    """

    _schema = {
        "properties": {
            "id": {"description": "Worker ID", "type": ["string", "null"]},
            "name": {"description": "Worker name", "type": ["string", "null"]},
        },
        "type": "object",
    }

    def __init__(self, id: Optional[str] = None, name: Optional[str] = None, **kwargs: Any) -> None:
        super(IdNameEntry, self).__init__(**kwargs)
        self.id = id
        self.name = name

    @schema_property("id")
    def id(self) -> Optional[str]:
        return self._property_id

    @id.setter
    def id(self, value: Optional[str]) -> None:
        if value is None:
            self._property_id = None
            return
        self.assert_isinstance(value, "id", six.string_types)
        self._property_id = value

    @schema_property("name")
    def name(self) -> Optional[str]:
        return self._property_name

    @name.setter
    def name(self, value: Optional[str]) -> None:
        if value is None:
            self._property_name = None
            return
        self.assert_isinstance(value, "name", six.string_types)
        self._property_name = value


class CurrentTaskEntry(NonStrictDataModel):
    """
    :param id: Worker ID
    :type id: str
    :param name: Worker name
    :type name: str
    :param running_time: Task running time
    :type running_time: int
    :param last_iteration: Last task iteration
    :type last_iteration: int
    """

    _schema = {
        "properties": {
            "id": {"description": "Worker ID", "type": ["string", "null"]},
            "last_iteration": {
                "description": "Last task iteration",
                "type": ["integer", "null"],
            },
            "name": {"description": "Worker name", "type": ["string", "null"]},
            "running_time": {
                "description": "Task running time",
                "type": ["integer", "null"],
            },
        },
        "type": "object",
    }

    def __init__(
        self,
        id: Optional[str] = None,
        name: Optional[str] = None,
        running_time: Optional[int] = None,
        last_iteration: Optional[int] = None,
        **kwargs: Any
    ) -> None:
        super(CurrentTaskEntry, self).__init__(**kwargs)
        self.id = id
        self.name = name
        self.running_time = running_time
        self.last_iteration = last_iteration

    @schema_property("id")
    def id(self) -> Optional[str]:
        return self._property_id

    @id.setter
    def id(self, value: Optional[str]) -> None:
        if value is None:
            self._property_id = None
            return
        self.assert_isinstance(value, "id", six.string_types)
        self._property_id = value

    @schema_property("name")
    def name(self) -> Optional[str]:
        return self._property_name

    @name.setter
    def name(self, value: Optional[str]) -> None:
        if value is None:
            self._property_name = None
            return
        self.assert_isinstance(value, "name", six.string_types)
        self._property_name = value

    @schema_property("running_time")
    def running_time(self) -> Optional[int]:
        return self._property_running_time

    @running_time.setter
    def running_time(self, value: Optional[int]) -> None:
        if value is None:
            self._property_running_time = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "running_time", six.integer_types)
        self._property_running_time = value

    @schema_property("last_iteration")
    def last_iteration(self) -> Optional[int]:
        return self._property_last_iteration

    @last_iteration.setter
    def last_iteration(self, value: Optional[int]) -> None:
        if value is None:
            self._property_last_iteration = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "last_iteration", six.integer_types)
        self._property_last_iteration = value


class QueueEntry(NonStrictDataModel):
    """
    :param id: Worker ID
    :type id: str
    :param name: Worker name
    :type name: str
    :param next_task: Next task in the queue
    :type next_task: IdNameEntry
    :param num_tasks: Number of task entries in the queue
    :type num_tasks: int
    """

    _schema = {
        "properties": {
            "id": {"description": "Worker ID", "type": ["string", "null"]},
            "name": {"description": "Worker name", "type": ["string", "null"]},
            "next_task": {
                "description": "Next task in the queue",
                "oneOf": [{"$ref": "#/definitions/id_name_entry"}, {"type": "null"}],
            },
            "num_tasks": {
                "description": "Number of task entries in the queue",
                "type": ["integer", "null"],
            },
        },
        "type": "object",
    }

    def __init__(
        self,
        id: Optional[str] = None,
        name: Optional[str] = None,
        next_task: Any = None,
        num_tasks: Optional[int] = None,
        **kwargs: Any
    ) -> None:
        super(QueueEntry, self).__init__(**kwargs)
        self.id = id
        self.name = name
        self.next_task = next_task
        self.num_tasks = num_tasks

    @schema_property("id")
    def id(self) -> Optional[str]:
        return self._property_id

    @id.setter
    def id(self, value: Optional[str]) -> None:
        if value is None:
            self._property_id = None
            return
        self.assert_isinstance(value, "id", six.string_types)
        self._property_id = value

    @schema_property("name")
    def name(self) -> Optional[str]:
        return self._property_name

    @name.setter
    def name(self, value: Optional[str]) -> None:
        if value is None:
            self._property_name = None
            return
        self.assert_isinstance(value, "name", six.string_types)
        self._property_name = value

    @schema_property("next_task")
    def next_task(self) -> Any:
        return self._property_next_task

    @next_task.setter
    def next_task(self, value: Any) -> None:
        if value is None:
            self._property_next_task = None
            return
        if isinstance(value, dict):
            value = IdNameEntry.from_dict(value)
        else:
            self.assert_isinstance(value, "next_task", IdNameEntry)
        self._property_next_task = value

    @schema_property("num_tasks")
    def num_tasks(self) -> Optional[int]:
        return self._property_num_tasks

    @num_tasks.setter
    def num_tasks(self, value: Optional[int]) -> None:
        if value is None:
            self._property_num_tasks = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "num_tasks", six.integer_types)
        self._property_num_tasks = value


class MachineStats(NonStrictDataModel):
    """
    :param cpu_usage: Average CPU usage per core
    :type cpu_usage: Sequence[float]
    :param gpu_usage: Average GPU usage per GPU card
    :type gpu_usage: Sequence[float]
    :param memory_used: Used memory MBs
    :type memory_used: int
    :param memory_free: Free memory MBs
    :type memory_free: int
    :param gpu_memory_free: GPU free memory MBs
    :type gpu_memory_free: Sequence[int]
    :param gpu_memory_used: GPU used memory MBs
    :type gpu_memory_used: Sequence[int]
    :param network_tx: Mbytes per second
    :type network_tx: int
    :param network_rx: Mbytes per second
    :type network_rx: int
    :param disk_free_home: Mbytes free space of /home drive
    :type disk_free_home: int
    :param disk_free_temp: Mbytes free space of /tmp drive
    :type disk_free_temp: int
    :param disk_read: Mbytes read per second
    :type disk_read: int
    :param disk_write: Mbytes write per second
    :type disk_write: int
    :param cpu_temperature: CPU temperature
    :type cpu_temperature: Sequence[float]
    :param gpu_temperature: GPU temperature
    :type gpu_temperature: Sequence[float]
    """

    _schema = {
        "properties": {
            "cpu_temperature": {
                "description": "CPU temperature",
                "items": {"type": "number"},
                "type": ["array", "null"],
            },
            "cpu_usage": {
                "description": "Average CPU usage per core",
                "items": {"type": "number"},
                "type": ["array", "null"],
            },
            "disk_free_home": {
                "description": "Mbytes free space of /home drive",
                "type": ["integer", "null"],
            },
            "disk_free_temp": {
                "description": "Mbytes free space of /tmp drive",
                "type": ["integer", "null"],
            },
            "disk_read": {
                "description": "Mbytes read per second",
                "type": ["integer", "null"],
            },
            "disk_write": {
                "description": "Mbytes write per second",
                "type": ["integer", "null"],
            },
            "gpu_memory_free": {
                "description": "GPU free memory MBs",
                "items": {"type": "integer"},
                "type": ["array", "null"],
            },
            "gpu_memory_used": {
                "description": "GPU used memory MBs",
                "items": {"type": "integer"},
                "type": ["array", "null"],
            },
            "gpu_temperature": {
                "description": "GPU temperature",
                "items": {"type": "number"},
                "type": ["array", "null"],
            },
            "gpu_usage": {
                "description": "Average GPU usage per GPU card",
                "items": {"type": "number"},
                "type": ["array", "null"],
            },
            "memory_free": {
                "description": "Free memory MBs",
                "type": ["integer", "null"],
            },
            "memory_used": {
                "description": "Used memory MBs",
                "type": ["integer", "null"],
            },
            "network_rx": {
                "description": "Mbytes per second",
                "type": ["integer", "null"],
            },
            "network_tx": {
                "description": "Mbytes per second",
                "type": ["integer", "null"],
            },
        },
        "type": "object",
    }

    def __init__(
        self,
        cpu_usage: Optional[List[float]] = None,
        gpu_usage: Optional[List[float]] = None,
        memory_used: Optional[int] = None,
        memory_free: Optional[int] = None,
        gpu_memory_free: Optional[List[int]] = None,
        gpu_memory_used: Optional[List[int]] = None,
        network_tx: Optional[int] = None,
        network_rx: Optional[int] = None,
        disk_free_home: Optional[int] = None,
        disk_free_temp: Optional[int] = None,
        disk_read: Optional[int] = None,
        disk_write: Optional[int] = None,
        cpu_temperature: Optional[List[float]] = None,
        gpu_temperature: Optional[List[float]] = None,
        **kwargs: Any
    ) -> None:
        super(MachineStats, self).__init__(**kwargs)
        self.cpu_usage = cpu_usage
        self.gpu_usage = gpu_usage
        self.memory_used = memory_used
        self.memory_free = memory_free
        self.gpu_memory_free = gpu_memory_free
        self.gpu_memory_used = gpu_memory_used
        self.network_tx = network_tx
        self.network_rx = network_rx
        self.disk_free_home = disk_free_home
        self.disk_free_temp = disk_free_temp
        self.disk_read = disk_read
        self.disk_write = disk_write
        self.cpu_temperature = cpu_temperature
        self.gpu_temperature = gpu_temperature

    @schema_property("cpu_usage")
    def cpu_usage(self) -> Optional[List[float]]:
        return self._property_cpu_usage

    @cpu_usage.setter
    def cpu_usage(self, value: Optional[List[float]]) -> None:
        if value is None:
            self._property_cpu_usage = None
            return
        self.assert_isinstance(value, "cpu_usage", (list, tuple))
        self.assert_isinstance(value, "cpu_usage", six.integer_types + (float,), is_array=True)
        self._property_cpu_usage = value

    @schema_property("gpu_usage")
    def gpu_usage(self) -> Optional[List[float]]:
        return self._property_gpu_usage

    @gpu_usage.setter
    def gpu_usage(self, value: Optional[List[float]]) -> None:
        if value is None:
            self._property_gpu_usage = None
            return
        self.assert_isinstance(value, "gpu_usage", (list, tuple))
        self.assert_isinstance(value, "gpu_usage", six.integer_types + (float,), is_array=True)
        self._property_gpu_usage = value

    @schema_property("memory_used")
    def memory_used(self) -> Optional[int]:
        return self._property_memory_used

    @memory_used.setter
    def memory_used(self, value: Optional[int]) -> None:
        if value is None:
            self._property_memory_used = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "memory_used", six.integer_types)
        self._property_memory_used = value

    @schema_property("memory_free")
    def memory_free(self) -> Optional[int]:
        return self._property_memory_free

    @memory_free.setter
    def memory_free(self, value: Optional[int]) -> None:
        if value is None:
            self._property_memory_free = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "memory_free", six.integer_types)
        self._property_memory_free = value

    @schema_property("gpu_memory_free")
    def gpu_memory_free(self) -> Optional[List[int]]:
        return self._property_gpu_memory_free

    @gpu_memory_free.setter
    def gpu_memory_free(self, value: Optional[List[int]]) -> None:
        if value is None:
            self._property_gpu_memory_free = None
            return
        self.assert_isinstance(value, "gpu_memory_free", (list, tuple))
        value = [int(v) if isinstance(v, float) and v.is_integer() else v for v in value]
        self.assert_isinstance(value, "gpu_memory_free", six.integer_types, is_array=True)
        self._property_gpu_memory_free = value

    @schema_property("gpu_memory_used")
    def gpu_memory_used(self) -> Optional[List[int]]:
        return self._property_gpu_memory_used

    @gpu_memory_used.setter
    def gpu_memory_used(self, value: Optional[List[int]]) -> None:
        if value is None:
            self._property_gpu_memory_used = None
            return
        self.assert_isinstance(value, "gpu_memory_used", (list, tuple))
        value = [int(v) if isinstance(v, float) and v.is_integer() else v for v in value]
        self.assert_isinstance(value, "gpu_memory_used", six.integer_types, is_array=True)
        self._property_gpu_memory_used = value

    @schema_property("network_tx")
    def network_tx(self) -> Optional[int]:
        return self._property_network_tx

    @network_tx.setter
    def network_tx(self, value: Optional[int]) -> None:
        if value is None:
            self._property_network_tx = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "network_tx", six.integer_types)
        self._property_network_tx = value

    @schema_property("network_rx")
    def network_rx(self) -> Optional[int]:
        return self._property_network_rx

    @network_rx.setter
    def network_rx(self, value: Optional[int]) -> None:
        if value is None:
            self._property_network_rx = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "network_rx", six.integer_types)
        self._property_network_rx = value

    @schema_property("disk_free_home")
    def disk_free_home(self) -> Optional[int]:
        return self._property_disk_free_home

    @disk_free_home.setter
    def disk_free_home(self, value: Optional[int]) -> None:
        if value is None:
            self._property_disk_free_home = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "disk_free_home", six.integer_types)
        self._property_disk_free_home = value

    @schema_property("disk_free_temp")
    def disk_free_temp(self) -> Optional[int]:
        return self._property_disk_free_temp

    @disk_free_temp.setter
    def disk_free_temp(self, value: Optional[int]) -> None:
        if value is None:
            self._property_disk_free_temp = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "disk_free_temp", six.integer_types)
        self._property_disk_free_temp = value

    @schema_property("disk_read")
    def disk_read(self) -> Optional[int]:
        return self._property_disk_read

    @disk_read.setter
    def disk_read(self, value: Optional[int]) -> None:
        if value is None:
            self._property_disk_read = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "disk_read", six.integer_types)
        self._property_disk_read = value

    @schema_property("disk_write")
    def disk_write(self) -> Optional[int]:
        return self._property_disk_write

    @disk_write.setter
    def disk_write(self, value: Optional[int]) -> None:
        if value is None:
            self._property_disk_write = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "disk_write", six.integer_types)
        self._property_disk_write = value

    @schema_property("cpu_temperature")
    def cpu_temperature(self) -> Optional[List[float]]:
        return self._property_cpu_temperature

    @cpu_temperature.setter
    def cpu_temperature(self, value: Optional[List[float]]) -> None:
        if value is None:
            self._property_cpu_temperature = None
            return
        self.assert_isinstance(value, "cpu_temperature", (list, tuple))
        self.assert_isinstance(value, "cpu_temperature", six.integer_types + (float,), is_array=True)
        self._property_cpu_temperature = value

    @schema_property("gpu_temperature")
    def gpu_temperature(self) -> Optional[List[float]]:
        return self._property_gpu_temperature

    @gpu_temperature.setter
    def gpu_temperature(self, value: Optional[List[float]]) -> None:
        if value is None:
            self._property_gpu_temperature = None
            return
        self.assert_isinstance(value, "gpu_temperature", (list, tuple))
        self.assert_isinstance(value, "gpu_temperature", six.integer_types + (float,), is_array=True)
        self._property_gpu_temperature = value


class GetActivityReportRequest(Request):
    """
    Returns count of active company workers in the selected time range.

    :param from_date: Starting time (in seconds from epoch) for collecting
        statistics
    :type from_date: float
    :param to_date: Ending time (in seconds from epoch) for collecting statistics
    :type to_date: float
    :param interval: Time interval in seconds for a single statistics point. The
        minimal value is 1
    :type interval: int
    """

    _service = "workers"
    _action = "get_activity_report"
    _version = "2.23"
    _schema = {
        "definitions": {},
        "properties": {
            "from_date": {
                "description": "Starting time (in seconds from epoch) for collecting statistics",
                "type": "number",
            },
            "interval": {
                "description": "Time interval in seconds for a single statistics point. The minimal value is 1",
                "type": "integer",
            },
            "to_date": {
                "description": "Ending time (in seconds from epoch) for collecting statistics",
                "type": "number",
            },
        },
        "required": ["from_date", "to_date", "interval"],
        "type": "object",
    }

    def __init__(self, from_date: float, to_date: float, interval: int, **kwargs: Any) -> None:
        super(GetActivityReportRequest, self).__init__(**kwargs)
        self.from_date = from_date
        self.to_date = to_date
        self.interval = interval

    @schema_property("from_date")
    def from_date(self) -> float:
        return self._property_from_date

    @from_date.setter
    def from_date(self, value: float) -> None:
        if value is None:
            self._property_from_date = None
            return
        self.assert_isinstance(value, "from_date", six.integer_types + (float,))
        self._property_from_date = value

    @schema_property("to_date")
    def to_date(self) -> float:
        return self._property_to_date

    @to_date.setter
    def to_date(self, value: float) -> None:
        if value is None:
            self._property_to_date = None
            return
        self.assert_isinstance(value, "to_date", six.integer_types + (float,))
        self._property_to_date = value

    @schema_property("interval")
    def interval(self) -> int:
        return self._property_interval

    @interval.setter
    def interval(self, value: int) -> None:
        if value is None:
            self._property_interval = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "interval", six.integer_types)
        self._property_interval = value


class GetActivityReportResponse(Response):
    """
    Response of workers.get_activity_report endpoint.

    :param total: Activity series that include all the workers that sent reports in
        the given time interval.
    :type total: ActivitySeries
    :param active: Activity series that include only workers that worked on a task
        in the given time interval.
    :type active: ActivitySeries
    """

    _service = "workers"
    _action = "get_activity_report"
    _version = "2.23"
    _schema = {
        "definitions": {
            "activity_series": {
                "properties": {
                    "counts": {
                        "description": "List of worker counts corresponding to the timestamps in the dates list. None values are returned for the dates with no workers.",
                        "items": {"type": "integer"},
                        "type": ["array", "null"],
                    },
                    "dates": {
                        "description": "List of timestamps (in seconds from epoch) in the acceding order. The timestamps are separated by the requested interval.",
                        "items": {"type": "integer"},
                        "type": ["array", "null"],
                    },
                },
                "type": "object",
            }
        },
        "properties": {
            "active": {
                "description": "Activity series that include only workers that worked on a task in the given time interval.",
                "oneOf": [{"$ref": "#/definitions/activity_series"}, {"type": "null"}],
            },
            "total": {
                "description": "Activity series that include all the workers that sent reports in the given time interval.",
                "oneOf": [{"$ref": "#/definitions/activity_series"}, {"type": "null"}],
            },
        },
        "type": "object",
    }

    def __init__(self, total: Any = None, active: Any = None, **kwargs: Any) -> None:
        super(GetActivityReportResponse, self).__init__(**kwargs)
        self.total = total
        self.active = active

    @schema_property("total")
    def total(self) -> Any:
        return self._property_total

    @total.setter
    def total(self, value: Any) -> None:
        if value is None:
            self._property_total = None
            return
        if isinstance(value, dict):
            value = ActivitySeries.from_dict(value)
        else:
            self.assert_isinstance(value, "total", ActivitySeries)
        self._property_total = value

    @schema_property("active")
    def active(self) -> Any:
        return self._property_active

    @active.setter
    def active(self, value: Any) -> None:
        if value is None:
            self._property_active = None
            return
        if isinstance(value, dict):
            value = ActivitySeries.from_dict(value)
        else:
            self.assert_isinstance(value, "active", ActivitySeries)
        self._property_active = value


class GetAllRequest(Request):
    """
    Returns information on all registered workers.

    :param last_seen: Filter out workers not active for more than last_seen
        seconds. A value or 0 or 'none' will disable the filter.
    :type last_seen: int
    :param tags: The list of allowed worker tags. Prepend tag value with '-' in
        order to exclude
    :type tags: Sequence[str]
    :param system_tags: The list of allowed worker system tags. Prepend tag value
        with '-' in order to exclude
    :type system_tags: Sequence[str]
    """

    _service = "workers"
    _action = "get_all"
    _version = "2.23"
    _schema = {
        "definitions": {},
        "properties": {
            "last_seen": {
                "default": 3600,
                "description": "Filter out workers not active for more than last_seen seconds.\n                        A value or 0 or 'none' will disable the filter.",
                "type": ["integer", "null"],
            },
            "system_tags": {
                "description": "The list of allowed worker system tags. Prepend tag value with '-' in order to exclude",
                "items": {"type": "string"},
                "type": ["array", "null"],
            },
            "tags": {
                "description": "The list of allowed worker tags. Prepend tag value with '-' in order to exclude",
                "items": {"type": "string"},
                "type": ["array", "null"],
            },
        },
        "type": "object",
    }

    def __init__(
        self,
        last_seen: Optional[int] = 3600,
        tags: Optional[List[str]] = None,
        system_tags: Optional[List[str]] = None,
        **kwargs: Any
    ) -> None:
        super(GetAllRequest, self).__init__(**kwargs)
        self.last_seen = last_seen
        self.tags = tags
        self.system_tags = system_tags

    @schema_property("last_seen")
    def last_seen(self) -> Optional[int]:
        return self._property_last_seen

    @last_seen.setter
    def last_seen(self, value: Optional[int]) -> None:
        if value is None:
            self._property_last_seen = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "last_seen", six.integer_types)
        self._property_last_seen = value

    @schema_property("tags")
    def tags(self) -> Optional[List[str]]:
        return self._property_tags

    @tags.setter
    def tags(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_tags = None
            return
        self.assert_isinstance(value, "tags", (list, tuple))
        self.assert_isinstance(value, "tags", six.string_types, is_array=True)
        self._property_tags = value

    @schema_property("system_tags")
    def system_tags(self) -> Optional[List[str]]:
        return self._property_system_tags

    @system_tags.setter
    def system_tags(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_system_tags = None
            return
        self.assert_isinstance(value, "system_tags", (list, tuple))
        self.assert_isinstance(value, "system_tags", six.string_types, is_array=True)
        self._property_system_tags = value


class GetAllResponse(Response):
    """
    Response of workers.get_all endpoint.

    :param workers:
    :type workers: Sequence[Worker]
    """

    _service = "workers"
    _action = "get_all"
    _version = "2.23"
    _schema = {
        "definitions": {
            "current_task_entry": {
                "properties": {
                    "id": {"description": "Worker ID", "type": ["string", "null"]},
                    "last_iteration": {
                        "description": "Last task iteration",
                        "type": ["integer", "null"],
                    },
                    "name": {"description": "Worker name", "type": ["string", "null"]},
                    "running_time": {
                        "description": "Task running time",
                        "type": ["integer", "null"],
                    },
                },
                "type": "object",
            },
            "id_name_entry": {
                "properties": {
                    "id": {"description": "Worker ID", "type": ["string", "null"]},
                    "name": {"description": "Worker name", "type": ["string", "null"]},
                },
                "type": "object",
            },
            "queue_entry": {
                "properties": {
                    "id": {"description": "Worker ID", "type": ["string", "null"]},
                    "name": {"description": "Worker name", "type": ["string", "null"]},
                    "next_task": {
                        "description": "Next task in the queue",
                        "oneOf": [
                            {"$ref": "#/definitions/id_name_entry"},
                            {"type": "null"},
                        ],
                    },
                    "num_tasks": {
                        "description": "Number of task entries in the queue",
                        "type": ["integer", "null"],
                    },
                },
                "type": "object",
            },
            "worker": {
                "properties": {
                    "company": {
                        "description": "Associated company",
                        "oneOf": [
                            {"$ref": "#/definitions/id_name_entry"},
                            {"type": "null"},
                        ],
                    },
                    "id": {"description": "Worker ID", "type": ["string", "null"]},
                    "ip": {
                        "description": "IP of the worker",
                        "type": ["string", "null"],
                    },
                    "key": {
                        "description": "Worker entry key",
                        "type": ["string", "null"],
                    },
                    "last_activity_time": {
                        "description": "Last activity time (even if an error occurred)",
                        "format": "date-time",
                        "type": ["string", "null"],
                    },
                    "last_report_time": {
                        "description": "Last successful report time",
                        "format": "date-time",
                        "type": ["string", "null"],
                    },
                    "project": {
                        "description": "Project in which currently executing task resides",
                        "oneOf": [
                            {"$ref": "#/definitions/id_name_entry"},
                            {"type": "null"},
                        ],
                    },
                    "queue": {
                        "description": "Queue from which running task was taken",
                        "oneOf": [
                            {"$ref": "#/definitions/queue_entry"},
                            {"type": "null"},
                        ],
                    },
                    "queues": {
                        "description": "List of queues on which the worker is listening",
                        "items": {"$ref": "#/definitions/queue_entry"},
                        "type": ["array", "null"],
                    },
                    "register_time": {
                        "description": "Registration time",
                        "format": "date-time",
                        "type": ["string", "null"],
                    },
                    "system_tags": {
                        "description": "System tags for the worker",
                        "items": {"type": "string"},
                        "type": ["array", "null"],
                    },
                    "tags": {
                        "description": "User tags for the worker",
                        "items": {"type": "string"},
                        "type": ["array", "null"],
                    },
                    "task": {
                        "description": "Task currently being run by the worker",
                        "oneOf": [
                            {"$ref": "#/definitions/current_task_entry"},
                            {"type": "null"},
                        ],
                    },
                    "user": {
                        "description": "Associated user (under whose credentials are used by the worker daemon)",
                        "oneOf": [
                            {"$ref": "#/definitions/id_name_entry"},
                            {"type": "null"},
                        ],
                    },
                },
                "type": "object",
            },
        },
        "properties": {
            "workers": {
                "items": {"$ref": "#/definitions/worker"},
                "type": ["array", "null"],
            }
        },
        "type": "object",
    }

    def __init__(self, workers: Optional[List[Any]] = None, **kwargs: Any) -> None:
        super(GetAllResponse, self).__init__(**kwargs)
        self.workers = workers

    @schema_property("workers")
    def workers(self) -> Optional[List[Any]]:
        return self._property_workers

    @workers.setter
    def workers(self, value: Optional[List[Any]]) -> None:
        if value is None:
            self._property_workers = None
            return
        self.assert_isinstance(value, "workers", (list, tuple))
        if any((isinstance(v, dict) for v in value)):
            value = [Worker.from_dict(v) if isinstance(v, dict) else v for v in value]
        else:
            self.assert_isinstance(value, "workers", Worker, is_array=True)
        self._property_workers = value


class GetMetricKeysRequest(Request):
    """
    Returns worker statistics metric keys grouped by categories.

    :param worker_ids: List of worker ids to collect metrics for. If not provided
        or empty then all the company workers metrics are analyzed.
    :type worker_ids: Sequence[str]
    """

    _service = "workers"
    _action = "get_metric_keys"
    _version = "2.23"
    _schema = {
        "definitions": {},
        "properties": {
            "worker_ids": {
                "description": "List of worker ids to collect metrics for. If not provided or empty then all the company workers metrics are analyzed.",
                "items": {"type": "string"},
                "type": ["array", "null"],
            }
        },
        "type": "object",
    }

    def __init__(self, worker_ids: Optional[List[str]] = None, **kwargs: Any) -> None:
        super(GetMetricKeysRequest, self).__init__(**kwargs)
        self.worker_ids = worker_ids

    @schema_property("worker_ids")
    def worker_ids(self) -> Optional[List[str]]:
        return self._property_worker_ids

    @worker_ids.setter
    def worker_ids(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_worker_ids = None
            return
        self.assert_isinstance(value, "worker_ids", (list, tuple))
        self.assert_isinstance(value, "worker_ids", six.string_types, is_array=True)
        self._property_worker_ids = value


class GetMetricKeysResponse(Response):
    """
    Response of workers.get_metric_keys endpoint.

    :param categories: List of unique metric categories found in the statistics of
        the requested workers.
    :type categories: Sequence[MetricsCategory]
    """

    _service = "workers"
    _action = "get_metric_keys"
    _version = "2.23"
    _schema = {
        "definitions": {
            "metrics_category": {
                "properties": {
                    "metric_keys": {
                        "description": "The names of the metrics in the category.",
                        "items": {"type": "string"},
                        "type": ["array", "null"],
                    },
                    "name": {
                        "description": "Name of the metrics category.",
                        "type": ["string", "null"],
                    },
                },
                "type": "object",
            }
        },
        "properties": {
            "categories": {
                "description": "List of unique metric categories found in the statistics of the requested workers.",
                "items": {"$ref": "#/definitions/metrics_category"},
                "type": ["array", "null"],
            }
        },
        "type": "object",
    }

    def __init__(self, categories: Optional[List[Any]] = None, **kwargs: Any) -> None:
        super(GetMetricKeysResponse, self).__init__(**kwargs)
        self.categories = categories

    @schema_property("categories")
    def categories(self) -> Optional[List[Any]]:
        return self._property_categories

    @categories.setter
    def categories(self, value: Optional[List[Any]]) -> None:
        if value is None:
            self._property_categories = None
            return
        self.assert_isinstance(value, "categories", (list, tuple))
        if any((isinstance(v, dict) for v in value)):
            value = [MetricsCategory.from_dict(v) if isinstance(v, dict) else v for v in value]
        else:
            self.assert_isinstance(value, "categories", MetricsCategory, is_array=True)
        self._property_categories = value


class GetStatsRequest(Request):
    """
    Returns statistics for the selected workers and time range aggregated by date intervals.

    :param worker_ids: List of worker ids to collect metrics for. If not provided
        or empty then all the company workers metrics are analyzed.
    :type worker_ids: Sequence[str]
    :param from_date: Starting time (in seconds from epoch) for collecting
        statistics
    :type from_date: float
    :param to_date: Ending time (in seconds from epoch) for collecting statistics
    :type to_date: float
    :param interval: Time interval in seconds for a single statistics point. The
        minimal value is 1
    :type interval: int
    :param items: List of metric keys and requested statistics
    :type items: Sequence[StatItem]
    :param split_by_variant: If true then break statistics by hardware sub types
    :type split_by_variant: bool
    """

    _service = "workers"
    _action = "get_stats"
    _version = "2.23"
    _schema = {
        "definitions": {
            "aggregation_type": {
                "description": "Metric aggregation type",
                "enum": ["avg", "min", "max"],
                "type": "string",
            },
            "stat_item": {
                "properties": {
                    "category": {
                        "oneOf": [
                            {"$ref": "#/definitions/aggregation_type"},
                            {"type": "null"},
                        ]
                    },
                    "key": {
                        "description": "Name of a metric",
                        "type": ["string", "null"],
                    },
                },
                "type": "object",
            },
        },
        "properties": {
            "from_date": {
                "description": "Starting time (in seconds from epoch) for collecting statistics",
                "type": "number",
            },
            "interval": {
                "description": "Time interval in seconds for a single statistics point. The minimal value is 1",
                "type": "integer",
            },
            "items": {
                "description": "List of metric keys and requested statistics",
                "items": {"$ref": "#/definitions/stat_item"},
                "type": "array",
            },
            "split_by_variant": {
                "default": False,
                "description": "If true then break statistics by hardware sub types",
                "type": "boolean",
            },
            "to_date": {
                "description": "Ending time (in seconds from epoch) for collecting statistics",
                "type": "number",
            },
            "worker_ids": {
                "description": "List of worker ids to collect metrics for. If not provided or empty then all the company workers metrics are analyzed.",
                "items": {"type": "string"},
                "type": ["array", "null"],
            },
        },
        "required": ["from_date", "to_date", "interval", "items"],
        "type": "object",
    }

    def __init__(
        self,
        from_date: float,
        to_date: float,
        interval: int,
        items: List[Any],
        worker_ids: Optional[List[str]] = None,
        split_by_variant: Optional[bool] = False,
        **kwargs: Any
    ) -> None:
        super(GetStatsRequest, self).__init__(**kwargs)
        self.worker_ids = worker_ids
        self.from_date = from_date
        self.to_date = to_date
        self.interval = interval
        self.items = items
        self.split_by_variant = split_by_variant

    @schema_property("worker_ids")
    def worker_ids(self) -> Optional[List[str]]:
        return self._property_worker_ids

    @worker_ids.setter
    def worker_ids(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_worker_ids = None
            return
        self.assert_isinstance(value, "worker_ids", (list, tuple))
        self.assert_isinstance(value, "worker_ids", six.string_types, is_array=True)
        self._property_worker_ids = value

    @schema_property("from_date")
    def from_date(self) -> float:
        return self._property_from_date

    @from_date.setter
    def from_date(self, value: float) -> None:
        if value is None:
            self._property_from_date = None
            return
        self.assert_isinstance(value, "from_date", six.integer_types + (float,))
        self._property_from_date = value

    @schema_property("to_date")
    def to_date(self) -> float:
        return self._property_to_date

    @to_date.setter
    def to_date(self, value: float) -> None:
        if value is None:
            self._property_to_date = None
            return
        self.assert_isinstance(value, "to_date", six.integer_types + (float,))
        self._property_to_date = value

    @schema_property("interval")
    def interval(self) -> int:
        return self._property_interval

    @interval.setter
    def interval(self, value: int) -> None:
        if value is None:
            self._property_interval = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "interval", six.integer_types)
        self._property_interval = value

    @schema_property("items")
    def items(self) -> List[Any]:
        return self._property_items

    @items.setter
    def items(self, value: List[Any]) -> None:
        if value is None:
            self._property_items = None
            return
        self.assert_isinstance(value, "items", (list, tuple))
        if any((isinstance(v, dict) for v in value)):
            value = [StatItem.from_dict(v) if isinstance(v, dict) else v for v in value]
        else:
            self.assert_isinstance(value, "items", StatItem, is_array=True)
        self._property_items = value

    @schema_property("split_by_variant")
    def split_by_variant(self) -> Optional[bool]:
        return self._property_split_by_variant

    @split_by_variant.setter
    def split_by_variant(self, value: Optional[bool]) -> None:
        if value is None:
            self._property_split_by_variant = None
            return
        self.assert_isinstance(value, "split_by_variant", (bool,))
        self._property_split_by_variant = value


class GetStatsResponse(Response):
    """
    Response of workers.get_stats endpoint.

    :param workers: List of the requested workers with their statistics
    :type workers: Sequence[WorkerStats]
    """

    _service = "workers"
    _action = "get_stats"
    _version = "2.23"
    _schema = {
        "definitions": {
            "aggregation_stats": {
                "properties": {
                    "aggregation": {
                        "oneOf": [
                            {"$ref": "#/definitions/aggregation_type"},
                            {"type": "null"},
                        ]
                    },
                    "values": {
                        "description": "List of values corresponding to the dates in metric statistics",
                        "items": {"type": "number"},
                        "type": ["array", "null"],
                    },
                },
                "type": "object",
            },
            "aggregation_type": {
                "description": "Metric aggregation type",
                "enum": ["avg", "min", "max"],
                "type": "string",
            },
            "metric_stats": {
                "properties": {
                    "dates": {
                        "description": "List of timestamps (in seconds from epoch) in the acceding order. The timestamps are separated by the requested interval. Timestamps where no workers activity was recorded are omitted.",
                        "items": {"type": "integer"},
                        "type": ["array", "null"],
                    },
                    "metric": {
                        "description": "Name of the metric (cpu_usage, memory_used etc.)",
                        "type": ["string", "null"],
                    },
                    "stats": {
                        "description": "Statistics data by type",
                        "items": {"$ref": "#/definitions/aggregation_stats"},
                        "type": ["array", "null"],
                    },
                    "variant": {
                        "description": "Name of the metric component. Set only if 'split_by_variant' was set in the request",
                        "type": ["string", "null"],
                    },
                },
                "type": "object",
            },
            "worker_stats": {
                "properties": {
                    "metrics": {
                        "description": "List of the metrics statistics for the worker",
                        "items": {"$ref": "#/definitions/metric_stats"},
                        "type": ["array", "null"],
                    },
                    "worker": {
                        "description": "ID of the worker",
                        "type": ["string", "null"],
                    },
                },
                "type": "object",
            },
        },
        "properties": {
            "workers": {
                "description": "List of the requested workers with their statistics",
                "items": {"$ref": "#/definitions/worker_stats"},
                "type": ["array", "null"],
            }
        },
        "type": "object",
    }

    def __init__(self, workers: Optional[List[Any]] = None, **kwargs: Any) -> None:
        super(GetStatsResponse, self).__init__(**kwargs)
        self.workers = workers

    @schema_property("workers")
    def workers(self) -> Optional[List[Any]]:
        return self._property_workers

    @workers.setter
    def workers(self, value: Optional[List[Any]]) -> None:
        if value is None:
            self._property_workers = None
            return
        self.assert_isinstance(value, "workers", (list, tuple))
        if any((isinstance(v, dict) for v in value)):
            value = [WorkerStats.from_dict(v) if isinstance(v, dict) else v for v in value]
        else:
            self.assert_isinstance(value, "workers", WorkerStats, is_array=True)
        self._property_workers = value


class RegisterRequest(Request):
    """
    Register a worker in the system. Called by the Worker Daemon.

    :param worker: Worker id. Must be unique in company.
    :type worker: str
    :param timeout: Registration timeout in seconds. If timeout seconds have passed
        since the worker's last call to register or status_report, the worker is
        automatically removed from the list of registered workers.
    :type timeout: int
    :param queues: List of queue IDs on which the worker is listening.
    :type queues: Sequence[str]
    :param tags: User tags for the worker
    :type tags: Sequence[str]
    :param system_tags: System tags for the worker
    :type system_tags: Sequence[str]
    """

    _service = "workers"
    _action = "register"
    _version = "2.23"
    _schema = {
        "definitions": {},
        "properties": {
            "queues": {
                "description": "List of queue IDs on which the worker is listening.",
                "items": {"type": "string"},
                "type": "array",
            },
            "system_tags": {
                "description": "System tags for the worker",
                "items": {"type": "string"},
                "type": "array",
            },
            "tags": {
                "description": "User tags for the worker",
                "items": {"type": "string"},
                "type": "array",
            },
            "timeout": {
                "default": 600,
                "description": "Registration timeout in seconds. If timeout seconds have passed since the worker's last call to register or status_report, the worker is automatically removed from the list of registered workers.",
                "type": "integer",
            },
            "worker": {
                "description": "Worker id. Must be unique in company.",
                "type": "string",
            },
        },
        "required": ["worker"],
        "type": "object",
    }

    def __init__(
        self,
        worker: str,
        timeout: Optional[int] = 600,
        queues: Optional[List[str]] = None,
        tags: Optional[List[str]] = None,
        system_tags: Optional[List[str]] = None,
        **kwargs: Any
    ) -> None:
        super(RegisterRequest, self).__init__(**kwargs)
        self.worker = worker
        self.timeout = timeout
        self.queues = queues
        self.tags = tags
        self.system_tags = system_tags

    @schema_property("worker")
    def worker(self) -> str:
        return self._property_worker

    @worker.setter
    def worker(self, value: str) -> None:
        if value is None:
            self._property_worker = None
            return
        self.assert_isinstance(value, "worker", six.string_types)
        self._property_worker = value

    @schema_property("timeout")
    def timeout(self) -> Optional[int]:
        return self._property_timeout

    @timeout.setter
    def timeout(self, value: Optional[int]) -> None:
        if value is None:
            self._property_timeout = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "timeout", six.integer_types)
        self._property_timeout = value

    @schema_property("queues")
    def queues(self) -> Optional[List[str]]:
        return self._property_queues

    @queues.setter
    def queues(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_queues = None
            return
        self.assert_isinstance(value, "queues", (list, tuple))
        self.assert_isinstance(value, "queues", six.string_types, is_array=True)
        self._property_queues = value

    @schema_property("tags")
    def tags(self) -> Optional[List[str]]:
        return self._property_tags

    @tags.setter
    def tags(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_tags = None
            return
        self.assert_isinstance(value, "tags", (list, tuple))
        self.assert_isinstance(value, "tags", six.string_types, is_array=True)
        self._property_tags = value

    @schema_property("system_tags")
    def system_tags(self) -> Optional[List[str]]:
        return self._property_system_tags

    @system_tags.setter
    def system_tags(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_system_tags = None
            return
        self.assert_isinstance(value, "system_tags", (list, tuple))
        self.assert_isinstance(value, "system_tags", six.string_types, is_array=True)
        self._property_system_tags = value


class RegisterResponse(Response):
    """
    Response of workers.register endpoint.

    """

    _service = "workers"
    _action = "register"
    _version = "2.23"
    _schema = {"definitions": {}, "properties": {}, "type": "object"}


class StatusReportRequest(Request):
    """
    Called periodically by the worker daemon to report machine status

    :param worker: Worker id.
    :type worker: str
    :param task: ID of a task currently being run by the worker. If no task is
        sent, the worker's task field will be cleared.
    :type task: str
    :param queue: ID of the queue from which task was received. If no queue is
        sent, the worker's queue field will be cleared.
    :type queue: str
    :param queues: List of queue IDs on which the worker is listening. If null, the
        worker's queues list will not be updated.
    :type queues: Sequence[str]
    :param timestamp: UNIX time in seconds since epoch.
    :type timestamp: int
    :param machine_stats: The machine statistics.
    :type machine_stats: MachineStats
    :param tags: New user tags for the worker
    :type tags: Sequence[str]
    :param system_tags: New system tags for the worker
    :type system_tags: Sequence[str]
    """

    _service = "workers"
    _action = "status_report"
    _version = "2.23"
    _schema = {
        "definitions": {
            "machine_stats": {
                "properties": {
                    "cpu_temperature": {
                        "description": "CPU temperature",
                        "items": {"type": "number"},
                        "type": ["array", "null"],
                    },
                    "cpu_usage": {
                        "description": "Average CPU usage per core",
                        "items": {"type": "number"},
                        "type": ["array", "null"],
                    },
                    "disk_free_home": {
                        "description": "Mbytes free space of /home drive",
                        "type": ["integer", "null"],
                    },
                    "disk_free_temp": {
                        "description": "Mbytes free space of /tmp drive",
                        "type": ["integer", "null"],
                    },
                    "disk_read": {
                        "description": "Mbytes read per second",
                        "type": ["integer", "null"],
                    },
                    "disk_write": {
                        "description": "Mbytes write per second",
                        "type": ["integer", "null"],
                    },
                    "gpu_memory_free": {
                        "description": "GPU free memory MBs",
                        "items": {"type": "integer"},
                        "type": ["array", "null"],
                    },
                    "gpu_memory_used": {
                        "description": "GPU used memory MBs",
                        "items": {"type": "integer"},
                        "type": ["array", "null"],
                    },
                    "gpu_temperature": {
                        "description": "GPU temperature",
                        "items": {"type": "number"},
                        "type": ["array", "null"],
                    },
                    "gpu_usage": {
                        "description": "Average GPU usage per GPU card",
                        "items": {"type": "number"},
                        "type": ["array", "null"],
                    },
                    "memory_free": {
                        "description": "Free memory MBs",
                        "type": ["integer", "null"],
                    },
                    "memory_used": {
                        "description": "Used memory MBs",
                        "type": ["integer", "null"],
                    },
                    "network_rx": {
                        "description": "Mbytes per second",
                        "type": ["integer", "null"],
                    },
                    "network_tx": {
                        "description": "Mbytes per second",
                        "type": ["integer", "null"],
                    },
                },
                "type": "object",
            }
        },
        "properties": {
            "machine_stats": {
                "$ref": "#/definitions/machine_stats",
                "description": "The machine statistics.",
            },
            "queue": {
                "description": "ID of the queue from which task was received. If no queue is sent, the worker's queue field will be cleared.",
                "type": "string",
            },
            "queues": {
                "description": "List of queue IDs on which the worker is listening. If null, the worker's queues list will not be updated.",
                "items": {"type": "string"},
                "type": "array",
            },
            "system_tags": {
                "description": "New system tags for the worker",
                "items": {"type": "string"},
                "type": "array",
            },
            "tags": {
                "description": "New user tags for the worker",
                "items": {"type": "string"},
                "type": "array",
            },
            "task": {
                "description": "ID of a task currently being run by the worker. If no task is sent, the worker's task field will be cleared.",
                "type": "string",
            },
            "timestamp": {
                "description": "UNIX time in seconds since epoch.",
                "type": "integer",
            },
            "worker": {"description": "Worker id.", "type": "string"},
        },
        "required": ["worker", "timestamp"],
        "type": "object",
    }

    def __init__(
        self,
        worker: str,
        timestamp: int,
        task: Optional[str] = None,
        queue: Optional[str] = None,
        queues: Optional[List[str]] = None,
        machine_stats: Any = None,
        tags: Optional[List[str]] = None,
        system_tags: Optional[List[str]] = None,
        **kwargs: Any
    ) -> None:
        super(StatusReportRequest, self).__init__(**kwargs)
        self.worker = worker
        self.task = task
        self.queue = queue
        self.queues = queues
        self.timestamp = timestamp
        self.machine_stats = machine_stats
        self.tags = tags
        self.system_tags = system_tags

    @schema_property("worker")
    def worker(self) -> str:
        return self._property_worker

    @worker.setter
    def worker(self, value: str) -> None:
        if value is None:
            self._property_worker = None
            return
        self.assert_isinstance(value, "worker", six.string_types)
        self._property_worker = value

    @schema_property("task")
    def task(self) -> Optional[str]:
        return self._property_task

    @task.setter
    def task(self, value: Optional[str]) -> None:
        if value is None:
            self._property_task = None
            return
        self.assert_isinstance(value, "task", six.string_types)
        self._property_task = value

    @schema_property("queue")
    def queue(self) -> Optional[str]:
        return self._property_queue

    @queue.setter
    def queue(self, value: Optional[str]) -> None:
        if value is None:
            self._property_queue = None
            return
        self.assert_isinstance(value, "queue", six.string_types)
        self._property_queue = value

    @schema_property("queues")
    def queues(self) -> Optional[List[str]]:
        return self._property_queues

    @queues.setter
    def queues(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_queues = None
            return
        self.assert_isinstance(value, "queues", (list, tuple))
        self.assert_isinstance(value, "queues", six.string_types, is_array=True)
        self._property_queues = value

    @schema_property("timestamp")
    def timestamp(self) -> int:
        return self._property_timestamp

    @timestamp.setter
    def timestamp(self, value: int) -> None:
        if value is None:
            self._property_timestamp = None
            return
        if isinstance(value, float) and value.is_integer():
            value = int(value)
        self.assert_isinstance(value, "timestamp", six.integer_types)
        self._property_timestamp = value

    @schema_property("machine_stats")
    def machine_stats(self) -> Any:
        return self._property_machine_stats

    @machine_stats.setter
    def machine_stats(self, value: Any) -> None:
        if value is None:
            self._property_machine_stats = None
            return
        if isinstance(value, dict):
            value = MachineStats.from_dict(value)
        else:
            self.assert_isinstance(value, "machine_stats", MachineStats)
        self._property_machine_stats = value

    @schema_property("tags")
    def tags(self) -> Optional[List[str]]:
        return self._property_tags

    @tags.setter
    def tags(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_tags = None
            return
        self.assert_isinstance(value, "tags", (list, tuple))
        self.assert_isinstance(value, "tags", six.string_types, is_array=True)
        self._property_tags = value

    @schema_property("system_tags")
    def system_tags(self) -> Optional[List[str]]:
        return self._property_system_tags

    @system_tags.setter
    def system_tags(self, value: Optional[List[str]]) -> None:
        if value is None:
            self._property_system_tags = None
            return
        self.assert_isinstance(value, "system_tags", (list, tuple))
        self.assert_isinstance(value, "system_tags", six.string_types, is_array=True)
        self._property_system_tags = value


class StatusReportResponse(Response):
    """
    Response of workers.status_report endpoint.

    """

    _service = "workers"
    _action = "status_report"
    _version = "2.23"
    _schema = {"definitions": {}, "properties": {}, "type": "object"}


class UnregisterRequest(Request):
    """
    Unregister a worker in the system. Called by the Worker Daemon.

    :param worker: Worker id. Must be unique in company.
    :type worker: str
    """

    _service = "workers"
    _action = "unregister"
    _version = "2.23"
    _schema = {
        "definitions": {},
        "properties": {
            "worker": {
                "description": "Worker id. Must be unique in company.",
                "type": "string",
            }
        },
        "required": ["worker"],
        "type": "object",
    }

    def __init__(self, worker: str, **kwargs: Any) -> None:
        super(UnregisterRequest, self).__init__(**kwargs)
        self.worker = worker

    @schema_property("worker")
    def worker(self) -> str:
        return self._property_worker

    @worker.setter
    def worker(self, value: str) -> None:
        if value is None:
            self._property_worker = None
            return
        self.assert_isinstance(value, "worker", six.string_types)
        self._property_worker = value


class UnregisterResponse(Response):
    """
    Response of workers.unregister endpoint.

    """

    _service = "workers"
    _action = "unregister"
    _version = "2.23"
    _schema = {"definitions": {}, "properties": {}, "type": "object"}


response_mapping = {
    GetAllRequest: GetAllResponse,
    RegisterRequest: RegisterResponse,
    UnregisterRequest: UnregisterResponse,
    StatusReportRequest: StatusReportResponse,
    GetMetricKeysRequest: GetMetricKeysResponse,
    GetStatsRequest: GetStatsResponse,
    GetActivityReportRequest: GetActivityReportResponse,
}
